\documentclass[11pt]{article}
\usepackage{url} 
\usepackage{graphicx}    % needed for including graphics e.g. EPS, PS
\topmargin -1.5cm        % read Lamport p.163
\oddsidemargin -0.04cm   % read Lamport p.163
\evensidemargin -0.04cm  % same as oddsidemargin but for left-hand pages
\textwidth 16.59cm
\textheight 21.94cm 
%\pagestyle{empty}       % Uncomment if don't want page numbers
\parskip 7.2pt           % sets spacing between paragraphs
%\renewcommand{\baselinestretch}{1.5} 	% Uncomment for 1.5 spacing between lines
 \parindent 0pt		  % sets leading space for paragraphs

 \begin{document}
 \begin{center}
 \Large{\textbf{COMP 388 - High Performance Computing - Project 2}}
 
 \small{Pawel Grocholski and Marty Heath}
 \end{center}

 \section{Background}
 \label{Background}
Since the creation of computers, performance has always been one of the main concerns and focus's of many computer scientists.  Knowing how to use multiple cores at a time has become a very important thing recently with the consumer sail of multi-core computers.  Benchmarking becomes key when considering the benifits and pitfalls of multi-core versus single core processors.  This project benchmarks the ShellSortDC code provided in the HPJPC project by Thomas W. Christopher and George K. Thiruvathukal.

\section{Methodology}
\label{Methodology}
For this project, we benchmarked the ShellSortDC problem, running it on two seperate dual core systems; one that is one year old and the other that is only a month old.  We wrote a script that would run the java program as many times as we set the arrary size to be our array increments by powers of two and running a sort on each of those arrays 30 times, in order to get an accurate mean of time.  The results were then plotted using gnuplot, both as individual computer results, and then both systems compared on the same graph.

\section{Results}
\label{Results}
\begin{left}
\includegraphics[scale=0.4]{results-paul.png}
\includegraphics[scale=0.4]{results-marty.png}
\linebreak
\end{left}
\begin{center}
\includegraphics[scale=0.7]{results-combined.png}
\end{center}
The results show that neither system was capable of handling a large number of threads, as no system was able to get through more than nine iterations of the outer loop in our bash script that runs the ShellSortDC program (each outer loop runs an internal loop 30 times). Our graphs are included nonetheless for benchmarking of the the arrays that were able to be sorted
\pagebreak

\section{Conclusion}
\label{Conclusion}
Our data shows clearly that the efficiency of this algorithm depends heavily on the number of threads available to the program, which is greatly limited in a consumer system.  In this case a single threaded algorithm would be able to sort a larger array than a multi-threaded array that places no limit on the number of threads created.  This code would most likely run on larger array sizes were we to place a limit on number of threads that the program is allowed to create.  

\end{document}

